package com.warom.sdg.util;

import android.content.Context;
import android.util.Log;

import com.warom.sdg.config.MeasurementPoint;
import com.warom.sdg.config.PlcMeasurementConfig;
import com.warom.sdg.model.GrainSituationEntity;
import com.warom.sdg.model.PlcDataEntity;
import com.warom.sdg.repository.GrainSituationRepository;
import com.warom.sdg.repository.PlcDataRepository;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

/**
 * 粮情数据计算工具类
 * 负责计算粮情数据的平均温湿度并保存到数据库
 */
public class GrainSituationCalculator {
    private static final String TAG = "GrainSituationCalc";

    // 平均值数据的特殊标识
    public static final int AVERAGE_GRAIN_DATA_CABLE_NO = 0;
    public static final String AVERAGE_GRAIN_DATA_CABLE_NAME = "仓内平均值";

    private final PlcDataRepository dataRepository;
    private final GrainSituationRepository grainSituationRepository;

    public GrainSituationCalculator(Context context) {
        this.dataRepository = new PlcDataRepository(context);
        this.grainSituationRepository = new GrainSituationRepository(context);
    }

    /**
     * 计算并保存粮情平均数据
     */
    public void calculateAndSave() {
        Log.d(TAG, "开始计算粮情平均数据...");

        // 从配置中获取所有粮情测点
        List<MeasurementPoint> grainPoints = PlcMeasurementConfig.grainSituationPoints;
        if (grainPoints == null || grainPoints.isEmpty()) {
            Log.w(TAG, "未配置任何粮情测点，跳过平均值计算。");
            return;
        }

        List<Float> temperatures = new ArrayList<>();
        List<Float> humidities = new ArrayList<>();

        // 异步获取所有最新的PLC数据
        dataRepository.getAllData(dataList -> {
            if (dataList == null || dataList.isEmpty()) {
                Log.w(TAG, "数据库中没有PLC数据，无法计算平均值。");
                return;
            }

            // 为了快速查找，将列表转换为Map (key: address, value: entity)
            Map<String, PlcDataEntity> latestDataMap = new HashMap<>();
            for (PlcDataEntity data : dataList) {
                // 因为getAllData是按时间戳降序的，所以第一个遇到的就是最新的
                if (!latestDataMap.containsKey(data.getAddress())) {
                    latestDataMap.put(data.getAddress(), data);
                }
            }

            for (MeasurementPoint point : grainPoints) {
                PlcDataEntity latestData = latestDataMap.get(point.getAddress());
                if (latestData != null && latestData.getValue() != null && !latestData.getValue().isEmpty()) {
                    try {
                        float value = Float.parseFloat(latestData.getValue());
                        if (point.getName().contains("温度")) {
                            temperatures.add(value);
                        } else if (point.getName().contains("湿度")) {
                            humidities.add(value);
                        }
                    } catch (NumberFormatException e) {
                        Log.e(TAG, "无法解析测点 " + point.getName() + " 的值为浮点数: " + latestData.getValue(), e);
                    }
                }
            }

            // 计算平均值
            float avgTemp = calculateAverage(temperatures);
            float avgHumidity = calculateAverage(humidities);

            Log.i(TAG, "计算完成 - 平均温度: " + avgTemp + "℃, 平均湿度: " + avgHumidity + "%");

            // 创建并保存实体
            if (!temperatures.isEmpty() || !humidities.isEmpty()) {
                GrainSituationEntity avgEntity = new GrainSituationEntity();
                avgEntity.setCableNo(AVERAGE_GRAIN_DATA_CABLE_NO);
                avgEntity.setCableName(AVERAGE_GRAIN_DATA_CABLE_NAME);
                avgEntity.setTemperature(avgTemp);
                avgEntity.setHumidity(avgHumidity);
                
                // 设置当前时间
                long timestamp = System.currentTimeMillis();
                avgEntity.setTimestamp(timestamp);
                
                // 格式化时间字符串
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault());
                avgEntity.setTimeString(sdf.format(new Date(timestamp)));
                
                avgEntity.setDeviceId(0); // 平均值数据不属于任何特定设备

                // 保存到数据库
                grainSituationRepository.insert(avgEntity,
                        () -> Log.d(TAG, "成功保存粮情平均数据。"),
                        error -> Log.e(TAG, "保存粮情平均数据失败: " + error)
                );
            }

        }, error -> Log.e(TAG, "获取全部PLC数据以计算平均值时失败: " + error));
    }

    /**
     * 计算浮点数列表的平均值
     * @param values 数值列表
     * @return 平均值，如果列表为空则返回0
     */
    private float calculateAverage(List<Float> values) {
        if (values == null || values.isEmpty()) {
            return 0.0f;
        }
        float sum = 0;
        for (float value : values) {
            sum += value;
        }
        return sum / values.size();
    }
} 